home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !preview / c / dviread < prev    next >
Encoding:
Text File  |  1991-03-02  |  53.2 KB  |  2,277 lines
  1. /* dviread.c --- Read dvi file; from dvitype.web.  */
  2.  
  3. #include "web2c.h"
  4. #include <stdarg.h>
  5.  
  6. int debug = 0;
  7.  
  8. /* <unix.io.h>: Simulation of Unix open/write etc in terms of <stdio.h> */
  9. /* version 0.01: created AM 18-oct-86. */
  10.  
  11. #ifndef __unix_io_h
  12. #define __unix_io_h
  13. #define __system_io
  14. #define _iob __iob
  15. #define FILEHANDLE int
  16. /* note that the following macro definitions rely on the internal       */
  17. /* details of the NorCroft C <stdio> implementation.                    */
  18.  
  19. /* flags for OPEN */
  20. #define O_RDONLY 0
  21. #define O_WRONLY 1
  22. #define O_RDWRITE 2
  23.  
  24. /* generates small code per module: */
  25. static char _open_mode[][4] = {"rb", "wb", "rb+"};
  26. static FILE *_open_temp;
  27. #define write(fd,buf,siz) fwrite(buf, 1, siz, &_iob[fd])
  28. #define unixread(fd,buf,siz) fread(buf, 1, siz, &_iob[fd])
  29. #define open(name,mode) \
  30.   ((_open_temp = fopen(name,_open_mode[mode]))!=0 ? _open_temp - _iob : -1)
  31. #define creat(name,prot) \
  32.   ((_open_temp = fopen(name,"wb"))!=0 ? _open_temp - _iob : -1)
  33. #define close(fd) fclose(&_iob[fd])
  34. #define lseek(fd,pos,org) fseek(&_iob[fd],pos,org)
  35. extern int _fisatty(FILE *);
  36. #define isatty(fd) _fisatty(&_iob[fd])
  37. #define unlink(file) remove(file)
  38. #define getpid() 1
  39.  
  40. #endif
  41.  
  42. /* end of <unix.io.h> */
  43. /* 9999 30 */ 
  44. #define maxfonts 100 
  45. #define maxwidths 10000 
  46. #define linelength 79 
  47. #define terminallinelength 150 
  48. #define stacksize 100 
  49. #define namesize 1000 
  50. #define namelength 256
  51. typedef schar ASCIIcode  ; 
  52. typedef file_ptr /* of  char */ textfile  ; 
  53. typedef unsigned char eightbits  ; 
  54. typedef file_ptr /* of  eightbits */ bytefile  ; 
  55. ASCIIcode xord[128]  ; 
  56. char xchr[256]  ; 
  57. bytefile dvifile  ; 
  58. bytefile tfmfile  ; 
  59. integer curloc  ; 
  60. char curname[namelength + 1], realnameoffile[namelength + 1]  ; 
  61. eightbits b0, b1, b2, b3  ; 
  62. integer fontnum[maxfonts + 1]  ; 
  63. integer fontname[maxfonts + 1]  ; 
  64. ASCIIcode names[namesize + 1]  ; 
  65. integer fontchecksum[maxfonts + 1]  ; 
  66. integer fontscaledsize[maxfonts + 1]  ; 
  67. integer fontdesignsize[maxfonts + 1]  ; 
  68. integer fontspace[maxfonts + 1]  ; 
  69. integer fontbc[maxfonts + 1]  ; 
  70. integer fontec[maxfonts + 1]  ; 
  71. integer widthbase[maxfonts + 1]  ; 
  72. integer width[maxwidths + 1]  ; 
  73. integer nf  ; 
  74. integer widthptr  ; 
  75. integer inwidth[256]  ; 
  76. integer tfmchecksum  ; 
  77. integer pixelwidth[maxwidths + 1]  ; 
  78. real conv  ; 
  79. real trueconv  ; 
  80. integer numerator, denominator  ; 
  81. integer mag  ; 
  82. schar outmode  ; 
  83. integer maxpages  ; 
  84. real resolution  ; 
  85. integer newmag  ; 
  86. integer startcount[10]  ; 
  87. boolean startthere[10]  ; 
  88. schar startvals  ; 
  89. integer count[10]  ; 
  90. ASCIIcode buffer[terminallinelength + 1]  ; 
  91. integer bufptr  ; 
  92. boolean inpostamble  ; 
  93. integer textptr  ; 
  94. ASCIIcode textbuf[linelength + 1]  ; 
  95. integer h, v, w, x, y, z, hh, vv  ; 
  96. integer hstack[stacksize + 1], vstack[stacksize + 1], wstack[stacksize + 1], 
  97. xstack[stacksize + 1], ystack[stacksize + 1], zstack[stacksize + 1]  ; 
  98. integer hhstack[stacksize + 1], vvstack[stacksize + 1]  ; 
  99. integer maxv  ; 
  100. integer maxh  ; 
  101. integer maxs  ; 
  102. integer maxvsofar, maxhsofar, maxssofar  ; 
  103. integer totalpages  ; 
  104. integer pagecount  ; 
  105. integer s  ; 
  106. integer ss  ; 
  107. integer curfont  ; 
  108. boolean showing  ; 
  109. integer oldbackpointer  ; 
  110. integer newbackpointer  ; 
  111. boolean started  ; 
  112. integer postloc  ; 
  113. integer firstbackpointer  ; 
  114. integer startloc  ; 
  115. integer k, m, n, p, q  ; 
  116.  
  117. char font_name[256];
  118. int font_size;
  119. int font_charwidth;
  120.  
  121. #include "dvitype.h"
  122. /* External procedures for dvitype                              */
  123. /*   Written by: H. Trickey, 2/19/83 (adapted from TeX's ext.c) */
  124.  
  125. #include <string.h>
  126.  
  127. #define TRUE    1
  128. #define FALSE   0
  129.  
  130. integer argc;
  131. char *fontpath;
  132. extern char *getenv();
  133.  
  134. /*
  135.  * setpaths is called to set up the pointer fontpath
  136.  * as follows:  if the user's environment has a value for TEXFONTS
  137.  * then use it;  otherwise, use defaultfontpath.
  138.  */
  139. setpaths()
  140. {
  141.         register char *envpath;
  142.         
  143.         if ((envpath = getenv("TEXFONTS")) != NULL)
  144.             fontpath = envpath;
  145.         else
  146.             fontpath = TEXFONTS;
  147. }
  148.  
  149. #define namelength 256   /* should agree with dvitype.ch */
  150. /* extern char curname[],realnameoffile[];*/ /* these have size namelength */
  151.  
  152. /*
  153.  *      testaccess(amode,filepath)
  154.  *
  155.  *  Test whether or not the file whose name is in the global curname
  156.  *  can be opened for reading (if mode=READACCESS)
  157.  *  or writing (if mode=WRITEACCESS).
  158.  *
  159.  *  The filepath argument is one of the ...FILEPATH constants defined below.
  160.  *  If the filename given in curname does not begin with '/', we try 
  161.  *  prepending all the ':'-separated areanames in the appropriate path to the
  162.  *  filename until access can be made, if it ever can.
  163.  *
  164.  *  The realnameoffile global array will contain the name that yielded an
  165.  *  access success.
  166.  */
  167.  
  168. #define READACCESS 4
  169. #define WRITEACCESS 2
  170.  
  171. #define NOFILEPATH 0
  172. #define FONTFILEPATH 3
  173.  
  174. static packrealnameoffile(char **cpp);
  175.  
  176.  
  177. testaccess(amode,filepath)
  178. int amode,filepath;
  179. {
  180.     register boolean ok;
  181.     register char *p;
  182.     char *curpathplace;
  183.     int f;
  184.     
  185.     switch(filepath) {
  186.         case NOFILEPATH: curpathplace = NULL; break;
  187.         case FONTFILEPATH: curpathplace = fontpath; break;
  188.         }
  189.     if (curname[0]=='/')        /* file name has absolute path */
  190.         curpathplace = NULL;
  191.     do {
  192.         packrealnameoffile(&curpathplace);
  193.         if (amode==READACCESS) {
  194.             FILE *temp;
  195.             /* use system call "access" to see if we could read it */
  196.             ok = FALSE;
  197.             if ((temp = fopen(realnameoffile, "rb")) != NULL) ok = TRUE;
  198.             if (ok) {
  199.               fclose(temp);
  200.             } else {
  201.               tfatal ("(dviread) Cannot open `%s'\n", realnameoffile);
  202.             }
  203.         } else {
  204.             /* WRITEACCESS: use creat to see if we could create it, but close
  205.             the file again if we're OK, to let pc open it for real */
  206.             f = creat(realnameoffile,0666);
  207.             ok = (f >= 0);
  208.             if (ok)
  209.                 (void) close(f);
  210.             }
  211.     } while (!ok && curpathplace != NULL);
  212.     if (ok) {  /* pad realnameoffile with blanks, as Pascal wants */
  213.         for (p = realnameoffile; *p != '\0'; p++)
  214.             /* nothing: find end of string */ ;
  215.         while (p < &(realnameoffile[namelength]))
  216.             *p++ = ' ';
  217.         }
  218.     return (ok);
  219. }
  220.  
  221. /*
  222.  * packrealnameoffile(cpp) makes realnameoffile contain the directory at *cpp,
  223.  * followed by '/', followed by the characters in curname up until the
  224.  * first blank there, and finally a '\0'.  The cpp pointer is left pointing
  225.  * at the next directory in the path.
  226.  * But: if *cpp == NULL, then we are supposed to use curname as is.
  227.  */
  228. static packrealnameoffile(cpp)
  229.     char **cpp;
  230. {
  231.     register char *p,*realname;
  232.     
  233.     realname = realnameoffile;
  234.     if ((p = *cpp)!=NULL) {
  235.         while ((*p != ',') && (*p != '\0')) {
  236.             *realname++ = *p++;
  237.             if (realname == &(realnameoffile[namelength-1]))
  238.                 break;
  239.             }
  240.         if (*p == '\0') *cpp = NULL; /* at end of path now */
  241.         else *cpp = p+1; /* else get past ':' */
  242. #ifndef ARM
  243.         *realname++ = '/';  /* separate the area from the name to follow */
  244. #endif
  245.         }
  246.     /* now append curname to realname... */
  247.     p = curname + 1;
  248.     while (*p != ' ') {
  249.         if (realname >= &(realnameoffile[namelength-1])) {
  250.             tfatal ("(dviread) Full file name is too long\n");
  251.             break;
  252.             }
  253.         *realname++ = *p++;
  254.         }
  255.     *realname = '\0';
  256. }
  257.  
  258. static char **gargv;
  259. argv(n, buf)
  260. int n;
  261. char buf[];
  262. {
  263.     (void) sprintf(buf+1, "%s ", gargv[n]);
  264. }
  265.  
  266.  
  267. dviread_main(ac, av)
  268.      int ac;
  269.      char **av;
  270. {
  271.   argc = ac;
  272.   gargv = av;
  273.   main_body();
  274. }
  275.  
  276.  
  277. #define char_index      strchr
  278.  
  279.  
  280. /* Open a file; don't return if error */
  281. FILE *openf(name, mode)
  282. char *name, *mode;
  283. {
  284.     FILE *result;
  285.     char *cp;
  286.  
  287.     --name;     /* All names are indexed starting at 1 */
  288.     cp = char_index(name, ' ');
  289.     if (cp) *cp = '\0';
  290.     result = fopen(name, mode);
  291.     if (result) return(result);
  292.     perror(name);
  293.     exit(1);
  294.     /*NOTREACHED*/
  295. }
  296.  
  297. /* Print real number r in format n:m */
  298. printreal(r, n, m)
  299. double r;
  300. int n,m;
  301. {
  302.     char fmt[50];
  303.  
  304.     (void) sprintf(fmt, "%%%d.%df", n, m);
  305.     (void) fprintf(stderr, fmt, r);
  306. }
  307.  
  308. /* Return true on end of line or eof of file, else false */
  309. eoln(f)
  310. FILE *f;
  311. {
  312.     register int c;
  313.  
  314.     if (feof(f)) return(1);
  315.     c = getc(f);
  316.     if (c != EOF)
  317.         (void) ungetc(c, f);
  318.     return (c == '\n' || c == EOF);
  319. }
  320.  
  321. /* Return true on end of file, else false */
  322. #undef eof
  323. int eof(f)
  324. FILE *f;
  325. {
  326.     register int c;
  327.  
  328.     if (feof(f)) return(1);
  329.     c = getc(f);
  330.     if (c != EOF)
  331.         (void) ungetc(c, f);
  332.     return (c == EOF);
  333. }
  334.  
  335. integer zround(f)
  336. double f;
  337. {
  338.     if (f >= 0.0) return(f + 0.5);
  339.     return(f - 0.5);
  340. }
  341.  
  342.  
  343. static int oldhh = -1;
  344. static int oldvv = -1;
  345. static int draw_rule = false;
  346.  
  347.  
  348. initialize () {
  349.     integer i  ; 
  350.   setpaths () ; 
  351.   {register integer for_end; i = 0 ; for_end = 31 ; if ( i <= for_end) do 
  352.     xchr [ i ] = '?' ; 
  353.   while ( i++ < for_end ) ; } 
  354.   xchr [ 32 ] = ' ' ; 
  355.   xchr [ 33 ] = '!' ; 
  356.   xchr [ 34 ] = '"' ; 
  357.   xchr [ 35 ] = '#' ; 
  358.   xchr [ 36 ] = '$' ; 
  359.   xchr [ 37 ] = '%' ; 
  360.   xchr [ 38 ] = '&' ; 
  361.   xchr [ 39 ] = '\'' ; 
  362.   xchr [ 40 ] = '(' ; 
  363.   xchr [ 41 ] = ')' ; 
  364.   xchr [ 42 ] = '*' ; 
  365.   xchr [ 43 ] = '+' ; 
  366.   xchr [ 44 ] = ',' ; 
  367.   xchr [ 45 ] = '-' ; 
  368.   xchr [ 46 ] = '.' ; 
  369.   xchr [ 47 ] = '/' ; 
  370.   xchr [ 48 ] = '0' ; 
  371.   xchr [ 49 ] = '1' ; 
  372.   xchr [ 50 ] = '2' ; 
  373.   xchr [ 51 ] = '3' ; 
  374.   xchr [ 52 ] = '4' ; 
  375.   xchr [ 53 ] = '5' ; 
  376.   xchr [ 54 ] = '6' ; 
  377.   xchr [ 55 ] = '7' ; 
  378.   xchr [ 56 ] = '8' ; 
  379.   xchr [ 57 ] = '9' ; 
  380.   xchr [ 58 ] = ':' ; 
  381.   xchr [ 59 ] = ';' ; 
  382.   xchr [ 60 ] = '<' ; 
  383.   xchr [ 61 ] = '=' ; 
  384.   xchr [ 62 ] = '>' ; 
  385.   xchr [ 63 ] = '?' ; 
  386.   xchr [ 64 ] = '@' ; 
  387.   xchr [ 65 ] = 'A' ; 
  388.   xchr [ 66 ] = 'B' ; 
  389.   xchr [ 67 ] = 'C' ; 
  390.   xchr [ 68 ] = 'D' ; 
  391.   xchr [ 69 ] = 'E' ; 
  392.   xchr [ 70 ] = 'F' ; 
  393.   xchr [ 71 ] = 'G' ; 
  394.   xchr [ 72 ] = 'H' ; 
  395.   xchr [ 73 ] = 'I' ; 
  396.   xchr [ 74 ] = 'J' ; 
  397.   xchr [ 75 ] = 'K' ; 
  398.   xchr [ 76 ] = 'L' ; 
  399.   xchr [ 77 ] = 'M' ; 
  400.   xchr [ 78 ] = 'N' ; 
  401.   xchr [ 79 ] = 'O' ; 
  402.   xchr [ 80 ] = 'P' ; 
  403.   xchr [ 81 ] = 'Q' ; 
  404.   xchr [ 82 ] = 'R' ; 
  405.   xchr [ 83 ] = 'S' ; 
  406.   xchr [ 84 ] = 'T' ; 
  407.   xchr [ 85 ] = 'U' ; 
  408.   xchr [ 86 ] = 'V' ; 
  409.   xchr [ 87 ] = 'W' ; 
  410.   xchr [ 88 ] = 'X' ; 
  411.   xchr [ 89 ] = 'Y' ; 
  412.   xchr [ 90 ] = 'Z' ; 
  413.   xchr [ 91 ] = '[' ; 
  414.   xchr [ 92 ] = '\\' ; 
  415.   xchr [ 93 ] = ']' ; 
  416.   xchr [ 94 ] = '^' ; 
  417.   xchr [ 95 ] = '_' ; 
  418.   xchr [ 96 ] = '`' ; 
  419.   xchr [ 97 ] = 'a' ; 
  420.   xchr [ 98 ] = 'b' ; 
  421.   xchr [ 99 ] = 'c' ; 
  422.   xchr [ 100 ] = 'd' ; 
  423.   xchr [ 101 ] = 'e' ; 
  424.   xchr [ 102 ] = 'f' ; 
  425.   xchr [ 103 ] = 'g' ; 
  426.   xchr [ 104 ] = 'h' ; 
  427.   xchr [ 105 ] = 'i' ; 
  428.   xchr [ 106 ] = 'j' ; 
  429.   xchr [ 107 ] = 'k' ; 
  430.   xchr [ 108 ] = 'l' ; 
  431.   xchr [ 109 ] = 'm' ; 
  432.   xchr [ 110 ] = 'n' ; 
  433.   xchr [ 111 ] = 'o' ; 
  434.   xchr [ 112 ] = 'p' ; 
  435.   xchr [ 113 ] = 'q' ; 
  436.   xchr [ 114 ] = 'r' ; 
  437.   xchr [ 115 ] = 's' ; 
  438.   xchr [ 116 ] = 't' ; 
  439.   xchr [ 117 ] = 'u' ; 
  440.   xchr [ 118 ] = 'v' ; 
  441.   xchr [ 119 ] = 'w' ; 
  442.   xchr [ 120 ] = 'x' ; 
  443.   xchr [ 121 ] = 'y' ; 
  444.   xchr [ 122 ] = 'z' ; 
  445.   xchr [ 123 ] = '{' ; 
  446.   xchr [ 124 ] = '|' ; 
  447.   xchr [ 125 ] = '}' ; 
  448.   xchr [ 126 ] = '~' ; 
  449.   {register integer for_end; i = 127 ; for_end = 255 ; if ( i <= for_end) do 
  450.     xchr [ i ] = '?' ; 
  451.   while ( i++ < for_end ) ; } 
  452.   {register integer for_end; i = 0 ; for_end = 127 ; if ( i <= for_end) do 
  453.     xord [ chr ( i ) ] = 32 ; 
  454.   while ( i++ < for_end ) ; } 
  455.   {register integer for_end; i = 32 ; for_end = 126 ; if ( i <= for_end) do 
  456.     xord [ xchr [ i ] ] = i ; 
  457.   while ( i++ < for_end ) ; } 
  458.   nf = 0 ; 
  459.   widthptr = 0 ; 
  460.   fontname [ 0 ] = 0 ; 
  461.   fontspace [ 0 ] = 0 ; 
  462.   outmode = 3 ; 
  463.   maxpages = 1000000L ; 
  464.   startvals = 0 ; 
  465.   startthere [ 0 ] = false ; 
  466.   inpostamble = false ; 
  467.   textptr = 0 ; 
  468.   maxv = 2147483548L ; 
  469.   maxh = 2147483548L ; 
  470.   maxs = stacksize + 1 ; 
  471.   maxvsofar = 0 ; 
  472.   maxhsofar = 0 ; 
  473.   maxssofar = 0 ; 
  474.   pagecount = 0 ; 
  475.   oldbackpointer = -1 ; 
  476.   started = false ; 
  477. } 
  478. opendvifile () {
  479.   if ( argc != 2 ) {
  480.     tfatal ("(dviread) %s\n", "Usage: dvitype <dvi-file>" ) ; 
  481.     uexit ( 1 ) ; 
  482.   } 
  483.   argv ( 1 , curname ) ; 
  484.   if ( testaccess ( 4 , 0 ) ) 
  485.   reset ( dvifile , realnameoffile ) ; 
  486.   else {
  487.           tfatal ("(dviread) %s\n", "DVI file not found" ) ; 
  488.     uexit ( 1 ) ; 
  489.   } 
  490.   curloc = 0 ; 
  491. } 
  492. opentfmfile () {
  493.     if ( testaccess ( 4 , 3 ) ) 
  494.   reset ( tfmfile , realnameoffile ) ; 
  495.   else {
  496.       
  497.     tfatal ("(dviread) TFM file not found (`%s')", realnameoffile) ; 
  498.     uexit ( 1 ) ; 
  499.   } 
  500. } 
  501. readtfmword () {
  502.   read ( tfmfile , b0 ) ; 
  503.   read ( tfmfile , b1 ) ; 
  504.   read ( tfmfile , b2 ) ; 
  505.   read ( tfmfile , b3 ) ; 
  506. } 
  507. integer getbyte () {
  508.     register integer Result; eightbits b  ; 
  509.   if ( eof ( dvifile ) ) {
  510.     tfatal ("(dviread) End of file detected.\n");
  511.     Result = 0 ; 
  512.   } else {
  513.       
  514.     read ( dvifile , b ) ; 
  515.     if (feof(dvifile)) tfatal ("(dviread) Last byte of file has been read.\n");
  516.     curloc = curloc + 1 ; 
  517.     Result = b ; 
  518.   } 
  519.   return(Result) ; 
  520. } 
  521. integer signedbyte () {
  522.     register integer Result; eightbits b  ; 
  523.   read ( dvifile , b ) ; 
  524.   curloc = curloc + 1 ; 
  525.   if ( b < 128 ) 
  526.   Result = b ; 
  527.   else Result = b - 256 ; 
  528.   return(Result) ; 
  529. } 
  530. integer gettwobytes () {
  531.     register integer Result; eightbits a, b  ; 
  532.   read ( dvifile , a ) ; 
  533.   read ( dvifile , b ) ; 
  534.   curloc = curloc + 2 ; 
  535.   Result = a * 256 + b ; 
  536.   return(Result) ; 
  537. } 
  538. integer signedpair () {
  539.     register integer Result; eightbits a, b  ; 
  540.   read ( dvifile , a ) ; 
  541.   read ( dvifile , b ) ; 
  542.   curloc = curloc + 2 ; 
  543.   if ( a < 128 ) 
  544.   Result = a * 256 + b ; 
  545.   else Result = ( a - 256 ) * 256 + b ; 
  546.   return(Result) ; 
  547. } 
  548. integer getthreebytes () {
  549.     register integer Result; eightbits a, b, c  ; 
  550.   read ( dvifile , a ) ; 
  551.   read ( dvifile , b ) ; 
  552.   read ( dvifile , c ) ; 
  553.   curloc = curloc + 3 ; 
  554.   Result = ( a * 256 + b ) * 256 + c ; 
  555.   return(Result) ; 
  556. } 
  557. integer signedtrio () {
  558.     register integer Result; eightbits a, b, c  ; 
  559.   read ( dvifile , a ) ; 
  560.   read ( dvifile , b ) ; 
  561.   read ( dvifile , c ) ; 
  562.   curloc = curloc + 3 ; 
  563.   if ( a < 128 ) 
  564.   Result = ( a * 256 + b ) * 256 + c ; 
  565.   else Result = ( ( a - 256 ) * 256 + b ) * 256 + c ; 
  566.   return(Result) ; 
  567. } 
  568. integer signedquad () {
  569.     register integer Result; eightbits a, b, c, d  ; 
  570.   read ( dvifile , a ) ; 
  571.   read ( dvifile , b ) ; 
  572.   read ( dvifile , c ) ; 
  573.   read ( dvifile , d ) ; 
  574.   curloc = curloc + 4 ; 
  575.   a = a&255; b = b&255; c = c&255; d = d&255;
  576.   Result = (a<<24) | (b<<16) | (c<<8) | d;
  577.   return(Result) ; 
  578. } 
  579. integer dvilength () {
  580.     register integer Result; zfseek ( dvifile , 0 , 2 ) ; 
  581.   Result = ftell ( dvifile ) ; 
  582.   return(Result) ; 
  583. } 
  584. zmovetobyte ( n ) 
  585. integer n ; 
  586. {zfseek ( dvifile , n , 0 ) ; 
  587. } 
  588. zprintfont ( f ) 
  589. integer f ; 
  590. {integer k  ; 
  591. static char fname[256];
  592. char *dest = &fname[0];
  593.   if ( f == nf ) 
  594.   (void) Fputs( stderr ,  "UNDEFINED!" ) ; 
  595.   else {
  596.       
  597.     {register integer for_end; k = fontname [ f ] ; for_end = fontname [ f + 
  598.     1 ] - 1 ; if ( k <= for_end) do 
  599.       (void) putc( (*dest++ = xchr [ names [ k ] ]) ,  stderr );
  600.     while ( k++ < for_end ) ; } 
  601.   } 
  602.   *dest = '\0';
  603.   strcpy(font_name, fname);
  604. } 
  605.  
  606. setfontname ( f ) 
  607. integer f ; 
  608. {integer k  ; 
  609. static char fname[256];
  610. char *dest = &fname[0];
  611.   if ( f == nf ) 
  612.   (void) Fputs( stderr ,  "UNDEFINED!" ) ; 
  613.   else {
  614.       
  615.     {register integer for_end; k = fontname [ f ] ; for_end = fontname [ f + 
  616.     1 ] - 1 ; if ( k <= for_end) do 
  617.       *dest++ = xchr [ names [ k ] ];
  618.     while ( k++ < for_end ) ; } 
  619.   } 
  620.   *dest = '\0';
  621.   strcpy(font_name, fname);
  622. } 
  623.  
  624. boolean zinTFM ( z ) 
  625. integer z ; 
  626. {/* 9997 9998 9999 */ register boolean Result; integer k  ; 
  627.   integer lh  ; 
  628.   integer nw  ; 
  629.   integer wp  ; 
  630.   integer alpha, beta  ; 
  631.   readtfmword () ; 
  632.   lh = b2 * 256 + b3 ; 
  633.   readtfmword () ; 
  634.   fontbc [ nf ] = b0 * 256 + b1 ; 
  635.   fontec [ nf ] = b2 * 256 + b3 ; 
  636.   if ( fontec [ nf ] < fontbc [ nf ] ) 
  637.   fontbc [ nf ] = fontec [ nf ] + 1 ; 
  638.   if ( widthptr + fontec [ nf ] - fontbc [ nf ] + 1 > maxwidths ) 
  639.   {
  640.     tfatal ("(dviread) Internal error: width table overflow");
  641.     goto lab9998 ; 
  642.   } 
  643.   wp = widthptr + fontec [ nf ] - fontbc [ nf ] + 1 ; 
  644.   readtfmword () ; 
  645.   nw = b0 * 256 + b1 ; 
  646.   if ( ( nw == 0 ) || ( nw > 256 ) ) 
  647.   goto lab9997 ; 
  648.   {register integer for_end; k = 1 ; for_end = 3 + lh ; if ( k <= for_end) do 
  649.     {
  650.       if ( eof ( tfmfile ) ) 
  651.       goto lab9997 ; 
  652.       readtfmword () ; 
  653.       if ( k == 4 ) 
  654.       if ( b0 < 128 ) 
  655.       tfmchecksum = ( ( b0 * 256 + b1 ) * 256 + b2 ) * 256 + b3 ; 
  656.       else tfmchecksum = ( ( ( b0 - 256 ) * 256 + b1 ) * 256 + b2 ) * 256 + b3 
  657.       ; 
  658.     } 
  659.   while ( k++ < for_end ) ; } 
  660.   if ( wp > 0 ) 
  661.   {register integer for_end; k = widthptr ; for_end = wp - 1 ; if ( k <= 
  662.   for_end) do 
  663.     {
  664.       readtfmword () ; 
  665.       if ( b0 > nw ) 
  666.       goto lab9997 ; 
  667.       width [ k ] = b0 ; 
  668.     } 
  669.   while ( k++ < for_end ) ; } 
  670.   {
  671.     alpha = 16 * z ; 
  672.     beta = 16 ; 
  673.     while ( z >= 8388608L ) {
  674.         
  675.       z = z / 2 ; 
  676.       beta = beta / 2 ; 
  677.     } 
  678.   } 
  679.   {register integer for_end; k = 0 ; for_end = nw - 1 ; if ( k <= for_end) do 
  680.     {
  681.       readtfmword () ; 
  682.       inwidth [ k ] = ( ( ( ( ( b3 * z ) / 256 ) + ( b2 * z ) ) / 256 ) + ( b1 
  683.       * z ) ) / beta ; 
  684.       if ( b0 > 0 ) 
  685.       if ( b0 < 255 ) 
  686.       goto lab9997 ; 
  687.       else inwidth [ k ] = inwidth [ k ] - alpha ; 
  688.     } 
  689.   while ( k++ < for_end ) ; } 
  690.   if ( inwidth [ 0 ] != 0 ) 
  691.   goto lab9997 ; 
  692.   widthbase [ nf ] = widthptr - fontbc [ nf ] ; 
  693.   if ( wp > 0 ) 
  694.   {register integer for_end; k = widthptr ; for_end = wp - 1 ; if ( k <= 
  695.   for_end) do 
  696.     if ( width [ k ] == 0 ) 
  697.     {
  698.       width [ k ] = 2147483647L ; 
  699.       pixelwidth [ k ] = 0 ; 
  700.     } 
  701.     else {
  702.         
  703.       width [ k ] = inwidth [ width [ k ] ] ; 
  704.       pixelwidth [ k ] = round ( conv * ( width [ k ] ) ) ; 
  705.     } 
  706.   while ( k++ < for_end ) ; } 
  707.   widthptr = wp ; 
  708.   Result = true ; 
  709.   goto lab9999 ; 
  710.   lab9997: tfatal ("(dviread) TFM file is bad" ) ; 
  711.   lab9998: Result = false ; 
  712.   lab9999: ; 
  713.   fclose ( tfmfile ); /* gt */
  714.   return(Result) ; 
  715. } 
  716. boolean startmatch () {
  717.     register boolean Result; schar k  ; 
  718.   boolean match  ; 
  719.   match = true ; 
  720.   {register integer for_end; k = 0 ; for_end = startvals ; if ( k <= for_end) 
  721.   do 
  722.     if ( startthere [ k ] && ( startcount [ k ] != count [ k ] ) ) 
  723.     match = false ; 
  724.   while ( k++ < for_end ) ; } 
  725.   Result = match ; 
  726.   return(Result) ; 
  727. } 
  728. inputln () {
  729.     integer k  ; 
  730.   flush ( stderr ) ; 
  731.   if ( eoln ( stdin ) ) 
  732.   readln ( stdin ) ; 
  733.   k = 0 ; 
  734.   while ( ( k < terminallinelength ) && ! eoln ( stdin ) ) {
  735.       
  736.     buffer [ k ] = xord [ getc ( stdin ) ] ; 
  737.     k = k + 1 ; 
  738.   } 
  739.   buffer [ k ] = 32 ; 
  740. } 
  741. integer getinteger () {
  742.     register integer Result; integer x  ; 
  743.   boolean negative  ; 
  744.   if ( buffer [ bufptr ] == 45 ) 
  745.   {
  746.     negative = true ; 
  747.     bufptr = bufptr + 1 ; 
  748.   } 
  749.   else negative = false ; 
  750.   x = 0 ; 
  751.   while ( ( buffer [ bufptr ] >= 48 ) && ( buffer [ bufptr ] <= 57 ) ) {
  752.       
  753.     x = 10 * x + buffer [ bufptr ] - 48 ; 
  754.     bufptr = bufptr + 1 ; 
  755.   } 
  756.   if ( negative ) 
  757.   Result = - (integer) x ; 
  758.   else Result = x ; 
  759.   return(Result) ; 
  760. } 
  761. dialog () {
  762.     /* 1 2 3 4 5 */ integer k  ; 
  763.   lab1:
  764.   outmode = 2 ; 
  765.   lab2:
  766.   startvals = 0 ; 
  767.   lab3:
  768.   maxpages = 1000000L ; 
  769.   lab4:
  770.   resolution = 72000.0 ; 
  771.   lab5:
  772.   newmag = 0 ; 
  773.  
  774. } 
  775. zdefinefont ( e ) 
  776. integer e ; 
  777. {integer f  ; 
  778.   integer p  ; 
  779.   integer n  ; 
  780.   integer c, q, d  ; 
  781.   integer r  ; 
  782.   integer j, k  ; 
  783.   boolean mismatch  ; 
  784.   if ( nf == maxfonts ) 
  785.   {
  786.     tfatal ("(dviread) Too many fonts in dvi file");
  787.     uexit ( 1 ) ; 
  788.   } 
  789.   fontnum [ nf ] = e ; 
  790.   f = 0 ; 
  791.   while ( fontnum [ f ] != e ) f = f + 1 ; 
  792.   c = signedquad () ; 
  793.   fontchecksum [ nf ] = c ; 
  794.   q = signedquad () ; 
  795.   fontscaledsize [ nf ] = q ; 
  796.   d = signedquad () ; 
  797.   fontdesignsize [ nf ] = d ; 
  798.   p = getbyte () ; 
  799.   n = getbyte () ; 
  800.   if ( fontname [ nf ] + n + p > namesize ) 
  801.   {
  802.     tfatal ("(dviread) name capacity exceeded");
  803.     uexit ( 1 ) ; 
  804.   } 
  805.   fontname [ nf + 1 ] = fontname [ nf ] + n + p ; 
  806.   if ( n + p == 0 ) 
  807.   (void) Fputs( stderr ,  "null font name!" ) ; 
  808.   else {
  809.       register integer for_end; k = fontname [ nf ] ; for_end = fontname [ 
  810.   nf + 1 ] - 1 ; if ( k <= for_end) do 
  811.     names [ k ] = getbyte () ; 
  812.   while ( k++ < for_end ) ; } 
  813.   nf = nf + 1 ; 
  814.   setfontname(nf-1);
  815.   nf = nf - 1 ; 
  816.   if ( ( ( outmode == 3 ) && inpostamble ) || ( ( outmode < 3 ) && ! 
  817.   inpostamble ) ) 
  818.   {
  819.     if ( f < nf ) 
  820.     tfatal ("(dviread) bad dvi file (repeated font def)");
  821.   } 
  822.   else {
  823.       
  824.     if ( f == nf ) 
  825.     tfatal ("(dviread) bad dvi file (fontsel before fontdef)");
  826.   } 
  827.   if ( f == nf ) 
  828.   {
  829.     {register integer for_end; k = 1 ; for_end = namelength ; if ( k <= 
  830.     for_end) do 
  831.       curname [ k ] = ' ' ; 
  832.     while ( k++ < for_end ) ; } 
  833.     r = 0 ; 
  834.     {register integer for_end; k = fontname [ nf ] ; for_end = fontname [ nf 
  835.     + 1 ] - 1 ; if ( k <= for_end) do 
  836.       {
  837.         r = r + 1 ; 
  838.         if ( r + 4 > namelength ) 
  839.         {
  840.           tfatal ("(dviread) capacity exceeded (font name too long)");
  841.           uexit ( 1 ) ; 
  842.         } 
  843.         curname [ r ] = xchr [ names [ k ] ] ; 
  844.       } 
  845.     while ( k++ < for_end ) ; } 
  846.     curname [ r + 1 ] = '.' ; 
  847.     curname [ r + 2 ] = 't' ; 
  848.     curname [ r + 3 ] = 'f' ; 
  849.     curname [ r + 4 ] = 'm' ; 
  850.     opentfmfile () ; 
  851.     if ( eof ( tfmfile ) ) 
  852.     (void) Fputs( stderr ,  "---not loaded, TFM file can't be opened!" ) ; 
  853.     else {
  854.         
  855.       if ( ( q <= 0 ) || ( q >= 134217728L ) ) 
  856.       tfatal ("(dviread) bad dvi file (scale)");
  857.       else if ( ( d <= 0 ) || ( d >= 134217728L ) ) 
  858.       tfatal ("(dviread) bad tfm file (bad design size)");
  859.       else if ( inTFM ( q ) ) 
  860.       {
  861.         fontspace [ nf ] = q / 6 ; 
  862.         if ( ( c != 0 ) && ( tfmchecksum != 0 ) && ( c != tfmchecksum ) ) 
  863.         {
  864.           fatal ("(dviread) WARNING: tfm checksum does not match");
  865.         } 
  866.         d = round ( ( 100.0 * conv * q ) / ((double) ( trueconv * d ) ) ) ; 
  867.         font_size = q; /*WIMP*/
  868.         nf = nf + 1 ; 
  869.         fontspace [ nf ] = 0 ; 
  870.       } 
  871.     } 
  872.   } 
  873.   else {
  874.       
  875.     if ( fontchecksum [ f ] != c ) 
  876.     tfatal ("(dviread) inconsistency (check sum doesn't match previous definition)");
  877.     if ( fontscaledsize [ f ] != q ) 
  878.     tfatal ("(dviread) inconsistency (scaled size doesn't match previous definition)");
  879.     if ( fontdesignsize [ f ] != d ) 
  880.     tfatal ("(dviread) inconsistency (design size doesn't match previous definition)");
  881.     j = fontname [ f ] ; 
  882.     k = fontname [ nf ] ; 
  883.     mismatch = false ; 
  884.     while ( j < fontname [ f + 1 ] ) {
  885.         
  886.       if ( names [ j ] != names [ k ] ) 
  887.       mismatch = true ; 
  888.       j = j + 1 ; 
  889.       k = k + 1 ; 
  890.     } 
  891.     if ( k != fontname [ nf + 1 ] ) 
  892.     mismatch = true ; 
  893.     if ( mismatch ) 
  894.     tfatal ("(dviread) inconsistency (font name doesn't match previous definition)");
  895.   } 
  896. } 
  897. flushtext () {
  898. integer k; 
  899.   if ( textptr > 0 ) {
  900.     if ( outmode > 0 ) {
  901.       register integer for_end;
  902.        k = 1 ;
  903.        if (xchr [ textbuf [ k ] ] == ' ') k++; /****** FUDGE!!! ******/
  904.        for_end = textptr ;
  905.        if ( k <= for_end) {
  906.          char text[256]; char *textp = &text[0];
  907.          do {
  908.            *textp++ = xchr [ textbuf [ k ] ];
  909.          } while ( k++ < for_end );
  910.          *textp = '\0';
  911.          DRAW_text(oldhh, oldvv, hh+font_charwidth, vv, text);  /*WIMPHOOK*/
  912.          oldhh = -1; oldvv = -1;
  913.        } 
  914.     } 
  915.     textptr = 0 ; 
  916.   } 
  917. } 
  918. zouttext ( c ) 
  919. ASCIIcode c ; 
  920. {if ( textptr == linelength - 2 ) 
  921.   flushtext () ; 
  922.   textptr = textptr + 1 ; 
  923.   textbuf [ textptr ] = c ; 
  924. } 
  925. integer zfirstpar ( o ) 
  926. eightbits o ; 
  927. {register integer Result; switch ( o ) 
  928.   {case 0 : 
  929.   case 1 : 
  930.   case 2 : 
  931.   case 3 : 
  932.   case 4 : 
  933.   case 5 : 
  934.   case 6 : 
  935.   case 7 : 
  936.   case 8 : 
  937.   case 9 : 
  938.   case 10 : 
  939.   case 11 : 
  940.   case 12 : 
  941.   case 13 : 
  942.   case 14 : 
  943.   case 15 : 
  944.   case 16 : 
  945.   case 17 : 
  946.   case 18 : 
  947.   case 19 : 
  948.   case 20 : 
  949.   case 21 : 
  950.   case 22 : 
  951.   case 23 : 
  952.   case 24 : 
  953.   case 25 : 
  954.   case 26 : 
  955.   case 27 : 
  956.   case 28 : 
  957.   case 29 : 
  958.   case 30 : 
  959.   case 31 : 
  960.   case 32 : 
  961.   case 33 : 
  962.   case 34 : 
  963.   case 35 : 
  964.   case 36 : 
  965.   case 37 : 
  966.   case 38 : 
  967.   case 39 : 
  968.   case 40 : 
  969.   case 41 : 
  970.   case 42 : 
  971.   case 43 : 
  972.   case 44 : 
  973.   case 45 : 
  974.   case 46 : 
  975.   case 47 : 
  976.   case 48 : 
  977.   case 49 : 
  978.   case 50 : 
  979.   case 51 : 
  980.   case 52 : 
  981.   case 53 : 
  982.   case 54 : 
  983.   case 55 : 
  984.   case 56 : 
  985.   case 57 : 
  986.   case 58 : 
  987.   case 59 : 
  988.   case 60 : 
  989.   case 61 : 
  990.   case 62 : 
  991.   case 63 : 
  992.   case 64 : 
  993.   case 65 : 
  994.   case 66 : 
  995.   case 67 : 
  996.   case 68 : 
  997.   case 69 : 
  998.   case 70 : 
  999.   case 71 : 
  1000.   case 72 : 
  1001.   case 73 : 
  1002.   case 74 : 
  1003.   case 75 : 
  1004.   case 76 : 
  1005.   case 77 : 
  1006.   case 78 : 
  1007.   case 79 : 
  1008.   case 80 : 
  1009.   case 81 : 
  1010.   case 82 : 
  1011.   case 83 : 
  1012.   case 84 : 
  1013.   case 85 : 
  1014.   case 86 : 
  1015.   case 87 : 
  1016.   case 88 : 
  1017.   case 89 : 
  1018.   case 90 : 
  1019.   case 91 : 
  1020.   case 92 : 
  1021.   case 93 : 
  1022.   case 94 : 
  1023.   case 95 : 
  1024.   case 96 : 
  1025.   case 97 : 
  1026.   case 98 : 
  1027.   case 99 : 
  1028.   case 100 : 
  1029.   case 101 : 
  1030.   case 102 : 
  1031.   case 103 : 
  1032.   case 104 : 
  1033.   case 105 : 
  1034.   case 106 : 
  1035.   case 107 : 
  1036.   case 108 : 
  1037.   case 109 : 
  1038.   case 110 : 
  1039.   case 111 : 
  1040.   case 112 : 
  1041.   case 113 : 
  1042.   case 114 : 
  1043.   case 115 : 
  1044.   case 116 : 
  1045.   case 117 : 
  1046.   case 118 : 
  1047.   case 119 : 
  1048.   case 120 : 
  1049.   case 121 : 
  1050.   case 122 : 
  1051.   case 123 : 
  1052.   case 124 : 
  1053.   case 125 : 
  1054.   case 126 : 
  1055.   case 127 : 
  1056.     Result = o - 0 ; 
  1057.     break ; 
  1058.   case 128 : 
  1059.   case 133 : 
  1060.   case 235 : 
  1061.   case 239 : 
  1062.   case 243 : 
  1063.     Result = getbyte () ; 
  1064.     break ; 
  1065.   case 129 : 
  1066.   case 134 : 
  1067.   case 236 : 
  1068.   case 240 : 
  1069.   case 244 : 
  1070.     Result = gettwobytes () ; 
  1071.     break ; 
  1072.   case 130 : 
  1073.   case 135 : 
  1074.   case 237 : 
  1075.   case 241 : 
  1076.   case 245 : 
  1077.     Result = getthreebytes () ; 
  1078.     break ; 
  1079.   case 143 : 
  1080.   case 148 : 
  1081.   case 153 : 
  1082.   case 157 : 
  1083.   case 162 : 
  1084.   case 167 : 
  1085.     Result = signedbyte () ; 
  1086.     break ; 
  1087.   case 144 : 
  1088.   case 149 : 
  1089.   case 154 : 
  1090.   case 158 : 
  1091.   case 163 : 
  1092.   case 168 : 
  1093.     Result = signedpair () ; 
  1094.     break ; 
  1095.   case 145 : 
  1096.   case 150 : 
  1097.   case 155 : 
  1098.   case 159 : 
  1099.   case 164 : 
  1100.   case 169 : 
  1101.     Result = signedtrio () ; 
  1102.     break ; 
  1103.   case 131 : 
  1104.   case 132 : 
  1105.   case 136 : 
  1106.   case 137 : 
  1107.   case 146 : 
  1108.   case 151 : 
  1109.   case 156 : 
  1110.   case 160 : 
  1111.   case 165 : 
  1112.   case 170 : 
  1113.   case 238 : 
  1114.   case 242 : 
  1115.   case 246 : 
  1116.     Result = signedquad () ; 
  1117.     break ; 
  1118.   case 138 : 
  1119.   case 139 : 
  1120.   case 140 : 
  1121.   case 141 : 
  1122.   case 142 : 
  1123.   case 247 : 
  1124.   case 248 : 
  1125.   case 249 : 
  1126.   case 250 : 
  1127.   case 251 : 
  1128.   case 252 : 
  1129.   case 253 : 
  1130.   case 254 : 
  1131.   case 255 : 
  1132.     Result = 0 ; 
  1133.     break ; 
  1134.   case 147 : 
  1135.     Result = w ; 
  1136.     break ; 
  1137.   case 152 : 
  1138.     Result = x ; 
  1139.     break ; 
  1140.   case 161 : 
  1141.     Result = y ; 
  1142.     break ; 
  1143.   case 166 : 
  1144.     Result = z ; 
  1145.     break ; 
  1146.   case 171 : 
  1147.   case 172 : 
  1148.   case 173 : 
  1149.   case 174 : 
  1150.   case 175 : 
  1151.   case 176 : 
  1152.   case 177 : 
  1153.   case 178 : 
  1154.   case 179 : 
  1155.   case 180 : 
  1156.   case 181 : 
  1157.   case 182 : 
  1158.   case 183 : 
  1159.   case 184 : 
  1160.   case 185 : 
  1161.   case 186 : 
  1162.   case 187 : 
  1163.   case 188 : 
  1164.   case 189 : 
  1165.   case 190 : 
  1166.   case 191 : 
  1167.   case 192 : 
  1168.   case 193 : 
  1169.   case 194 : 
  1170.   case 195 : 
  1171.   case 196 : 
  1172.   case 197 : 
  1173.   case 198 : 
  1174.   case 199 : 
  1175.   case 200 : 
  1176.   case 201 : 
  1177.   case 202 : 
  1178.   case 203 : 
  1179.   case 204 : 
  1180.   case 205 : 
  1181.   case 206 : 
  1182.   case 207 : 
  1183.   case 208 : 
  1184.   case 209 : 
  1185.   case 210 : 
  1186.   case 211 : 
  1187.   case 212 : 
  1188.   case 213 : 
  1189.   case 214 : 
  1190.   case 215 : 
  1191.   case 216 : 
  1192.   case 217 : 
  1193.   case 218 : 
  1194.   case 219 : 
  1195.   case 220 : 
  1196.   case 221 : 
  1197.   case 222 : 
  1198.   case 223 : 
  1199.   case 224 : 
  1200.   case 225 : 
  1201.   case 226 : 
  1202.   case 227 : 
  1203.   case 228 : 
  1204.   case 229 : 
  1205.   case 230 : 
  1206.   case 231 : 
  1207.   case 232 : 
  1208.   case 233 : 
  1209.   case 234 : 
  1210.     Result = o - 171 ; 
  1211.     break ; 
  1212.   } 
  1213.   return(Result) ; 
  1214. } 
  1215. integer zrulepixels ( x ) 
  1216. integer x ; 
  1217. {register integer Result; integer n  ; 
  1218.   n = trunc ( conv * x ) ; 
  1219.   if ( n < conv * x ) 
  1220.   Result = n + 1 ; 
  1221.   else Result = n ; 
  1222.   return(Result) ; 
  1223. } 
  1224. boolean zspecialcases ( o , p , a ) 
  1225. eightbits o ; 
  1226. integer p , a ; 
  1227. {/* 46 44 30 9998 */ register boolean Result; integer q  ; 
  1228.   integer k  ; 
  1229.   boolean badchar  ; 
  1230.   boolean pure  ; 
  1231.   integer vvv  ; 
  1232.   pure = true ; 
  1233.   switch ( o ) 
  1234.   {case 157 : 
  1235.   case 158 : 
  1236.   case 159 : 
  1237.   case 160 : 
  1238.     {
  1239.       if ( abs ( p ) >= 5 * fontspace [ curfont ] ) 
  1240.       vv = round ( conv * ( v + p ) ) ; 
  1241.       else vv = vv + round ( conv * ( p ) ) ; 
  1242.       if ( outmode > 0 ) 
  1243.       {
  1244.         flushtext () ; 
  1245.         showing = true ; 
  1246.       } 
  1247.       goto lab44 ; 
  1248.     } 
  1249.     break ; 
  1250.   case 161 : 
  1251.   case 162 : 
  1252.   case 163 : 
  1253.   case 164 : 
  1254.   case 165 : 
  1255.     {
  1256.       y = p ; 
  1257.       if ( abs ( p ) >= 5 * fontspace [ curfont ] ) 
  1258.       vv = round ( conv * ( v + p ) ) ; 
  1259.       else vv = vv + round ( conv * ( p ) ) ; 
  1260.       if ( outmode > 0 ) 
  1261.       {
  1262.         flushtext () ; 
  1263.         showing = true ; 
  1264.       } 
  1265.       goto lab44 ; 
  1266.     } 
  1267.     break ; 
  1268.   case 166 : 
  1269.   case 167 : 
  1270.   case 168 : 
  1271.   case 169 : 
  1272.   case 170 : 
  1273.     {
  1274.       z = p ; 
  1275.       if ( abs ( p ) >= 5 * fontspace [ curfont ] ) 
  1276.       vv = round ( conv * ( v + p ) ) ; 
  1277.       else vv = vv + round ( conv * ( p ) ) ; 
  1278.       if ( outmode > 0 ) 
  1279.       {
  1280.         flushtext () ; 
  1281.         showing = true ; 
  1282.       } 
  1283.       goto lab44 ; 
  1284.     } 
  1285.     break ; 
  1286.   case 171 : 
  1287.   case 172 : 
  1288.   case 173 : 
  1289.   case 174 : 
  1290.   case 175 : 
  1291.   case 176 : 
  1292.   case 177 : 
  1293.   case 178 : 
  1294.   case 179 : 
  1295.   case 180 : 
  1296.   case 181 : 
  1297.   case 182 : 
  1298.   case 183 : 
  1299.   case 184 : 
  1300.   case 185 : 
  1301.   case 186 : 
  1302.   case 187 : 
  1303.   case 188 : 
  1304.   case 189 : 
  1305.   case 190 : 
  1306.   case 191 : 
  1307.   case 192 : 
  1308.   case 193 : 
  1309.   case 194 : 
  1310.   case 195 : 
  1311.   case 196 : 
  1312.   case 197 : 
  1313.   case 198 : 
  1314.   case 199 : 
  1315.   case 200 : 
  1316.   case 201 : 
  1317.   case 202 : 
  1318.   case 203 : 
  1319.   case 204 : 
  1320.   case 205 : 
  1321.   case 206 : 
  1322.   case 207 : 
  1323.   case 208 : 
  1324.   case 209 : 
  1325.   case 210 : 
  1326.   case 211 : 
  1327.   case 212 : 
  1328.   case 213 : 
  1329.   case 214 : 
  1330.   case 215 : 
  1331.   case 216 : 
  1332.   case 217 : 
  1333.   case 218 : 
  1334.   case 219 : 
  1335.   case 220 : 
  1336.   case 221 : 
  1337.   case 222 : 
  1338.   case 223 : 
  1339.   case 224 : 
  1340.   case 225 : 
  1341.   case 226 : 
  1342.   case 227 : 
  1343.   case 228 : 
  1344.   case 229 : 
  1345.   case 230 : 
  1346.   case 231 : 
  1347.   case 232 : 
  1348.   case 233 : 
  1349.   case 234 : 
  1350.     {
  1351.       if ( outmode > 0 ) 
  1352.       {
  1353.         flushtext () ; 
  1354.         showing = true ; 
  1355.         DRAW_selfont(p);  /*WIMPHOOK*/
  1356.       } 
  1357.       goto lab46 ; 
  1358.     } 
  1359.     break ; 
  1360.   case 235 : 
  1361.   case 236 : 
  1362.   case 237 : 
  1363.   case 238 : 
  1364.     {
  1365.       if ( outmode > 0 ) 
  1366.       {
  1367.         flushtext () ; 
  1368.         showing = true ; 
  1369.         DRAW_selfont(p);  /*WIMPHOOK*/
  1370.       } 
  1371.       goto lab46 ; 
  1372.     } 
  1373.     break ; 
  1374.   case 243 : 
  1375.   case 244 : 
  1376.   case 245 : 
  1377.   case 246 : 
  1378.     {
  1379.       if ( outmode > 0 ) 
  1380.       {
  1381.         flushtext () ; 
  1382.         showing = true ; 
  1383.       } 
  1384.       definefont ( p ) ; 
  1385.       DRAW_deffont(p, font_name, font_size>>12, mag);  /*WIMPHOOK*/
  1386.       goto lab30 ; 
  1387.     } 
  1388.     break ; 
  1389.   case 239 : 
  1390.   case 240 : 
  1391.   case 241 : 
  1392.   case 242 : 
  1393.     {
  1394.       if ( outmode > 0 ) 
  1395.       {
  1396.         flushtext () ; 
  1397.         showing = true ; 
  1398.         /* We regressed a version since IAY was working from 1.0 and
  1399.            we were at 1.1 -- so let's redo this 'fix' */
  1400.         /*tfatal ("BARF %ld%s%s",  (long)a , ": " , "xxx '" ) ; */
  1401.       } 
  1402.       badchar = false ; 
  1403.       if ( p < 0 ) 
  1404.       if ( ! showing ) 
  1405.       {
  1406.         flushtext () ; 
  1407.         showing = true ; 
  1408.         tfatal ("(dviread) bad dvi file (string of negative length)");
  1409.       } 
  1410.       else
  1411.       tfatal ("(dviread) bad dvi file (string of negative length)");
  1412.       {register integer for_end; k = 1 ; for_end = p ; if ( k <= for_end) do 
  1413.         {
  1414.           q = getbyte () ; 
  1415.           if ( ( q < 32 ) || ( q > 126 ) ) 
  1416.           badchar = true ; 
  1417.           if ( showing ) 
  1418.           (void) putc( xchr [ q ] ,  stderr );
  1419.         } 
  1420.       while ( k++ < for_end ) ; } 
  1421.       if ( showing ) 
  1422.       (void) putc( '\'' ,  stderr );
  1423.       if ( badchar ) 
  1424.       if ( ! showing ) 
  1425.       {
  1426.         flushtext () ; 
  1427.         showing = true ; 
  1428.         tfatal ("(dviread) bad dvi file (non-ASCII character in xxx command)");
  1429.       } 
  1430.       else
  1431.       tfatal ("(dviread) bad dvi file (non-ASCII character in xxx command)");
  1432.       goto lab30 ; 
  1433.     } 
  1434.     break ; 
  1435.   case 247 : 
  1436.     {
  1437.       if ( ! showing ) 
  1438.       {
  1439.         flushtext () ; 
  1440.         showing = true ; 
  1441.         tfatal ("(dviread) bad dvi file (preamble command within a page)");
  1442.       } 
  1443.       else
  1444.       tfatal ("(dviread) bad dvi file (preamble command within a page)");
  1445.       goto lab9998 ; 
  1446.     } 
  1447.     break ; 
  1448.   case 248 : 
  1449.   case 249 : 
  1450.     {
  1451.       if ( ! showing ) 
  1452.       {
  1453.         flushtext () ; 
  1454.         showing = true ; 
  1455.         tfatal ("(dviread) bad dvi file (postamble command within a page)");
  1456.       } 
  1457.       else
  1458.         tfatal ("(dviread) bad dvi file (postamble command within a page)");
  1459.       goto lab9998 ; 
  1460.     } 
  1461.     break ; 
  1462.     default: 
  1463.     {
  1464.       if ( ! showing ) 
  1465.       {
  1466.         flushtext () ; 
  1467.         showing = true ; 
  1468.         tfatal ("(dviread) bad dfi file (undefined command)");
  1469.       } 
  1470.       else
  1471.         tfatal ("(dviread) bad dfi file (undefined command)");
  1472.       goto lab30 ; 
  1473.     } 
  1474.     break ; 
  1475.   } 
  1476.   lab44: if ( ( v > 0 ) && ( p > 0 ) ) 
  1477.   if ( v > 2147483647L - p ) 
  1478.   {
  1479.     if ( ! showing ) 
  1480.     {
  1481.       flushtext () ; 
  1482.       showing = true ; 
  1483.       fatal ("(dviread) WARNING: arithmetic overflow! parameter changed from %d to %d", p, 2147483647L - v );
  1484.     } 
  1485.     else
  1486.       fatal ("(dviread) WARNING: arithmetic overflow! parameter changed from %d to %d", p, 2147483647L - v );
  1487.     p = 2147483647L - v ; 
  1488.   } 
  1489.   if ( ( v < 0 ) && ( p < 0 ) ) 
  1490.   if ( - (integer) v > p + 2147483647L ) 
  1491.   {
  1492.     if ( ! showing ) 
  1493.     {
  1494.       flushtext () ; 
  1495.       showing = true ; 
  1496.       fatal ("(dviread) WARNING: arithmetic overflow! parameter changed from %d to %d", p, (int) (-v - 2147483647L));
  1497.     } 
  1498.     else
  1499.       fatal ("(dviread) WARNING: arithmetic overflow! parameter changed from %d to %d", p, (int) (-v - 2147483647L));
  1500.     p = ( - (integer) v ) - 2147483647L ; 
  1501.   } 
  1502.   vvv = round ( conv * ( v + p ) ) ; 
  1503.   if ( abs ( vvv - vv ) > 2 ) 
  1504.   if ( vvv > vv ) 
  1505.   vv = vvv - 2 ; 
  1506.   else vv = vvv + 2 ; 
  1507.   v = v + p ; 
  1508.   if ( abs ( v ) > maxvsofar ) 
  1509.   {
  1510.     if ( abs ( v ) > maxv + 99 ) 
  1511.     {
  1512.       if ( ! showing ) 
  1513.       {
  1514.         flushtext () ; 
  1515.         showing = true ; 
  1516. /*
  1517.         tfatal ("%ld%s%s%ld%c",  (long)a , ": " , "warning: |v|>" , (long)maxv , '!' ) ; 
  1518. */
  1519.       } 
  1520.       else
  1521. /*
  1522.       tfatal ("%c%s%ld%c",  ' ' , "warning: |v|>" , (long)maxv , '!' ) ; 
  1523. */
  1524.       maxv = abs ( v ) ; 
  1525.     } 
  1526.     maxvsofar = abs ( v ) ; 
  1527.   } 
  1528.   goto lab30 ; 
  1529.   lab46: fontnum [ nf ] = p ; 
  1530.   curfont = 0 ; 
  1531.   while ( fontnum [ curfont ] != p ) curfont = curfont + 1 ; 
  1532.   goto lab30 ; 
  1533.   lab9998: pure = false ; 
  1534.   lab30: Result = pure ; 
  1535.   return(Result) ; 
  1536. } 
  1537.  
  1538. boolean dopage () {
  1539.     /* 41 42 43 45 30 9998 9999 */ register boolean Result; 
  1540.   eightbits o  ; 
  1541.   integer p, q  ; 
  1542.   integer a  ; 
  1543.   integer hhh  ; 
  1544.   curfont = nf ; 
  1545.   s = 0 ; 
  1546.   h = 0 ; 
  1547.   v = 0 ; 
  1548.   w = 0 ; 
  1549.   x = 0 ; 
  1550.   y = 0 ; 
  1551.   z = 0 ; 
  1552.   hh = 0 ; 
  1553.   vv = 0 ;
  1554.   DRAW_startpage();  /*WIMPHOOK*/
  1555.   while ( true ) {
  1556.       
  1557.     a = curloc ; 
  1558.     showing = false ; 
  1559.     o = getbyte () ; 
  1560.     p = firstpar ( o ) ; 
  1561.     if ( eof ( dvifile ) ) 
  1562.     {
  1563.       tfatal ("(dviread) bad dvi file (the file ended prematurely)");
  1564.       uexit ( 1 ) ; 
  1565.     } 
  1566.     if ( o < 128 ) 
  1567.     {
  1568.       if ( ( o > 32 ) && ( o <= 126 ) ) 
  1569.       {
  1570.         outtext ( p ) ; 
  1571.         if ( outmode >= 2 ) 
  1572.         {
  1573.           showing = true ; 
  1574.           font_charwidth = pixelwidth [ widthbase [ curfont ] + p ];
  1575.           if ((oldhh == -1) && (oldvv == -1)) {
  1576.             oldhh = hh; oldvv = vv;  /* Note start of rectangle */ /*WIMP*/
  1577.           }
  1578.         } 
  1579.       } 
  1580.       else if ( outmode > 0 ) 
  1581.       {
  1582.         flushtext () ; 
  1583.         showing = true ; 
  1584.          DRAW_char(hh, vv, p);  /*WIMPHOOK*/
  1585.       } 
  1586.       goto lab41 ; 
  1587.     } 
  1588.     else switch ( o ) 
  1589.     {case 128 : 
  1590.     case 129 : 
  1591.     case 130 : 
  1592.     case 131 : 
  1593.       {
  1594.         if ( outmode > 0 ) 
  1595.         {
  1596.           flushtext () ; 
  1597.           showing = true ; 
  1598. /*
  1599.           tfatal ("%ld%s%s%ld%c%ld",  (long)a , ": " , "set" , (long)o - 127 , ' ' , (long)p ) ; 
  1600. */
  1601.         } 
  1602.         goto lab41 ; 
  1603.       } 
  1604.       break ; 
  1605.     case 133 : 
  1606.     case 134 : 
  1607.     case 135 : 
  1608.     case 136 : 
  1609.       {
  1610.         if ( outmode > 0 ) 
  1611.         {
  1612.           flushtext () ; 
  1613.           showing = true ; 
  1614. /*
  1615.           tfatal ("%ld%s%s%ld%c%ld",  (long)a , ": " , "put" , (long)o - 132 , ' ' , (long)p ) ; 
  1616. */
  1617.         } 
  1618.         goto lab41 ; 
  1619.       } 
  1620.       break ; 
  1621.     case 132 : 
  1622.       {
  1623.         if ( outmode > 0 ) 
  1624.         {
  1625.           flushtext () ; 
  1626.           showing = true ; 
  1627.         }
  1628.         draw_rule = true; /*WIMP*/
  1629.         goto lab42 ; 
  1630.       } 
  1631.       break ; 
  1632.     case 137 : 
  1633.       {
  1634.         if ( outmode > 0 ) 
  1635.         {
  1636.           flushtext () ; 
  1637.           showing = true ; 
  1638.         } 
  1639.         draw_rule = true;/*WIMP*/
  1640.         goto lab42 ; 
  1641.       } 
  1642.       break ; 
  1643.     case 138 : 
  1644.       {
  1645.         if ( outmode >= 2 ) 
  1646.         {
  1647.           showing = true ; 
  1648. /*
  1649.           tfatal ("%ld%s%s",  (long)a , ": " , "nop" ) ; 
  1650. */
  1651.         } 
  1652.         goto lab30 ; 
  1653.       } 
  1654.       break ; 
  1655.     case 139 : 
  1656.       {
  1657.         if ( ! showing ) 
  1658.         {
  1659.           flushtext () ; 
  1660.           showing = true ; 
  1661.           tfatal ("(dviread) bad dvi file (bop occurred before eop)");
  1662.         } 
  1663.         else
  1664.           tfatal ("(dviread) bad dvi file (bop occurred before eop)");
  1665.         goto lab9998 ; 
  1666.       } 
  1667.       break ; 
  1668.     case 140 : 
  1669.       {
  1670.         if ( outmode > 0 ) 
  1671.         {
  1672.           flushtext () ; 
  1673.           showing = true ; 
  1674.         } 
  1675.         if ( s != 0 ) 
  1676.         if ( ! showing ) 
  1677.         {
  1678.           flushtext () ; 
  1679.           showing = true ; 
  1680.           tfatal ("(dviread) bad dvi file (stack not empty at end of page)");
  1681.         } 
  1682.         else
  1683.           tfatal ("(dviread) bad dvi file (stack not empty at end of page)");
  1684.         Result = true ; 
  1685.         DRAW_endpage(maxh/* page_width */,  maxv/* page_height */,  count/* page_counters */); /*WIMPHOOK*/
  1686.         goto lab9999 ; 
  1687.       } 
  1688.       break ; 
  1689.     case 141 : 
  1690.       {
  1691.         if ( outmode > 0 ) 
  1692.         {
  1693.           flushtext () ; 
  1694.           showing = true ; 
  1695.         } 
  1696.         if ( s == maxssofar ) 
  1697.         {
  1698.           maxssofar = s + 1 ; 
  1699.           if ( s == maxs ) 
  1700.           if ( ! showing ) 
  1701.           {
  1702.             flushtext () ; 
  1703.             showing = true ; 
  1704.             tfatal ("(dviread) bad dvi file (deeper than claimed in postamble)");
  1705.           } 
  1706.           else
  1707.             tfatal ("(dviread) bad dvi file (deeper than claimed in postamble)");
  1708.           ; 
  1709.           if ( s == stacksize ) 
  1710.           {
  1711.             if ( ! showing ) 
  1712.             {
  1713.               flushtext () ; 
  1714.               showing = true ; 
  1715.               tfatal ("(dviread) capacity exceeded (stack)");
  1716.             } 
  1717.             else
  1718.               tfatal ("(dviread) capacity exceeded (stack)");
  1719.             goto lab9998 ; 
  1720.           } 
  1721.         } 
  1722.         hstack [ s ] = h ; 
  1723.         vstack [ s ] = v ; 
  1724.         wstack [ s ] = w ; 
  1725.         xstack [ s ] = x ; 
  1726.         ystack [ s ] = y ; 
  1727.         zstack [ s ] = z ; 
  1728.         hhstack [ s ] = hh ; 
  1729.         vvstack [ s ] = vv ; 
  1730.         s = s + 1 ; 
  1731.         ss = s - 1 ; 
  1732.         goto lab45 ; 
  1733.       } 
  1734.       break ; 
  1735.     case 142 : 
  1736.       {
  1737.         if ( outmode > 0 ) 
  1738.         {
  1739.           flushtext () ; 
  1740.           showing = true ; 
  1741.         } 
  1742.         if ( s == 0 ) 
  1743.         if ( ! showing ) 
  1744.         {
  1745.           flushtext () ; 
  1746.           showing = true ; 
  1747.           tfatal ("(dviread) bad dvi file"); 
  1748.         } 
  1749.         else
  1750.           tfatal ("(dviread) bad dvi file");
  1751.         else {
  1752.             
  1753.           s = s - 1 ; 
  1754.           hh = hhstack [ s ] ; 
  1755.           vv = vvstack [ s ] ; 
  1756.           h = hstack [ s ] ; 
  1757.           v = vstack [ s ] ; 
  1758.           w = wstack [ s ] ; 
  1759.           x = xstack [ s ] ; 
  1760.           y = ystack [ s ] ; 
  1761.           z = zstack [ s ] ; 
  1762.         } 
  1763.         ss = s ; 
  1764.         goto lab45 ; 
  1765.       } 
  1766.       break ; 
  1767.     case 143 : 
  1768.     case 144 : 
  1769.     case 145 : 
  1770.     case 146 : 
  1771.       {
  1772. #ifdef PROPER
  1773.         if ( ( p >= fontspace [ curfont ] ) || ( p <= -4 * fontspace [ curfont 
  1774.         ] ) ) 
  1775.         {
  1776.           outtext ( 32 ) ; 
  1777.           hh = round ( conv * ( h + p ) ) ; 
  1778.         } 
  1779.         else
  1780. #endif
  1781.         {
  1782.           if (outmode > 0) flushtext();
  1783.           hh = hh + round ( conv * ( p ) ) ; 
  1784.         }
  1785.         if ( outmode >= 2 ) 
  1786.         {
  1787.           showing = true ; 
  1788.         } 
  1789.         q = p ; 
  1790.         goto lab43 ; 
  1791.       } 
  1792.       break ; 
  1793.     case 147 : 
  1794.     case 148 : 
  1795.     case 149 : 
  1796.     case 150 : 
  1797.     case 151 : 
  1798.       {
  1799.         w = p ; 
  1800. #ifdef PROPER
  1801.         if ( ( p >= fontspace [ curfont ] ) || ( p <= -4 * fontspace [ curfont 
  1802.         ] ) ) 
  1803.         {
  1804.           outtext ( 32 ) ; 
  1805.           hh = round ( conv * ( h + p ) ) ; 
  1806.         } 
  1807.         else
  1808. #endif
  1809.         {
  1810.           if (outmode > 0) flushtext();
  1811.           hh = hh + round ( conv * ( p ) ) ; 
  1812.         }
  1813.         if ( outmode >= 2 ) 
  1814.         {
  1815.           showing = true ; 
  1816.         } 
  1817.         q = p ; 
  1818.         goto lab43 ; 
  1819.       } 
  1820.       break ; 
  1821.     case 152 : 
  1822.     case 153 : 
  1823.     case 154 : 
  1824.     case 155 : 
  1825.     case 156 : 
  1826.       {
  1827.         x = p ; 
  1828. #ifdef PROPER
  1829.         if ( ( p >= fontspace [ curfont ] ) || ( p <= -4 * fontspace [ curfont 
  1830.         ] ) ) 
  1831.         {
  1832.           outtext ( 32 ) ; 
  1833.           hh = round ( conv * ( h + p ) ) ; 
  1834.         } 
  1835.         else
  1836. #endif
  1837.         {
  1838.           if (outmode > 0) flushtext();
  1839.           hh = hh + round ( conv * ( p ) ) ; 
  1840.         }
  1841.         if ( outmode >= 2 ) 
  1842.         {
  1843.           showing = true ; 
  1844.         } 
  1845.         q = p ; 
  1846.         goto lab43 ; 
  1847.       } 
  1848.       break ; 
  1849.       default: 
  1850.       if ( specialcases ( o , p , a ) ) 
  1851.       goto lab30 ; 
  1852.       else goto lab9998 ; 
  1853.       break ; 
  1854.     } 
  1855.     lab41: if ( p < 0 ) 
  1856.     p = 255 - ( ( -1 - p ) % 256 ) ; 
  1857.     else if ( p >= 256 ) 
  1858.     p = p % 256 ; 
  1859.     if ( ( p < fontbc [ curfont ] ) || ( p > fontec [ curfont ] ) ) 
  1860.     q = 2147483647L ; 
  1861.     else q = width [ widthbase [ curfont ] + p ] ; 
  1862.     if ( q == 2147483647L ) 
  1863.     {
  1864.       if ( ! showing ) 
  1865.       {
  1866.         flushtext () ; 
  1867.         showing = true ; 
  1868.         tfatal ("(dviread) bad dvi file (character invalid in font)"); 
  1869.       } 
  1870.       else
  1871.         tfatal ("(dviread) bad dvi file (character invalid in font)");
  1872.       printfont ( curfont ) ; 
  1873.       if ( curfont != nf ) 
  1874.       (void) putc( '!' ,  stderr );
  1875.     } 
  1876.     if ( o >= 133 ) 
  1877.     goto lab30 ; 
  1878.     if ( q == 2147483647L ) 
  1879.     q = 0 ; 
  1880.     else hh = hh + pixelwidth [ widthbase [ curfont ] + p ] ; 
  1881.     goto lab43 ; 
  1882.     lab42: q = signedquad () ; 
  1883.     if ( showing ) 
  1884.     {
  1885.       if ( ( p <= 0 ) || ( q <= 0 ) ) {
  1886.         (void) Fputs( stderr ,  " (invisible)" ) ; 
  1887.       } else {
  1888.         if (draw_rule) {
  1889.           DRAW_rule(hh, vv, (long)rulepixels ( p ) ,
  1890.                             (long)rulepixels ( q ));
  1891.         }
  1892.       }
  1893.     } 
  1894.     draw_rule = false;
  1895.     if ( o == 137 ) 
  1896.     goto lab30 ; 
  1897.     hh = hh + rulepixels ( q ) ; 
  1898.     goto lab43 ; 
  1899.     lab43: if ( ( h > 0 ) && ( q > 0 ) ) 
  1900.     if ( h > 2147483647L - q ) 
  1901.     {
  1902.       if ( ! showing ) 
  1903.       {
  1904.         flushtext () ; 
  1905.         showing = true ; 
  1906.         tfatal ("%ld%s%s%ld%s%ld",  (long)a , ": " ,         "arithmetic overflow! parameter changed from " , (long)q , " to " ,         (long)2147483647L - h ) ; 
  1907.       } 
  1908.       else
  1909.       tfatal ("%c%s%ld%s%ld",  ' ' ,       "arithmetic overflow! parameter changed from " , (long)q , " to " ,       (long)2147483647L - h ) ; 
  1910.       q = 2147483647L - h ; 
  1911.     } 
  1912.     if ( ( h < 0 ) && ( q < 0 ) ) 
  1913.     if ( - (integer) h > q + 2147483647L ) 
  1914.     {
  1915.       if ( ! showing ) 
  1916.       {
  1917.         flushtext () ; 
  1918.         showing = true ; 
  1919.         tfatal ("%ld%s%s%ld%s%ld",  (long)a , ": " ,         "arithmetic overflow! parameter changed from " , (long)q , " to " , (long)(         - (integer) h ) - 2147483647L ) ; 
  1920.       } 
  1921.       else
  1922.       tfatal ("%c%s%ld%s%ld",  ' ' ,       "arithmetic overflow! parameter changed from " , (long)q , " to " , (long)(       - (integer) h ) - 2147483647L ) ; 
  1923.       q = ( - (integer) h ) - 2147483647L ; 
  1924.     } 
  1925.     hhh = round ( conv * ( h + q ) ) ; 
  1926.     if ( abs ( hhh - hh ) > 2 ) 
  1927.     if ( hhh > hh ) 
  1928.     hh = hhh - 2 ; 
  1929.     else hh = hhh + 2 ; 
  1930.     h = h + q ; 
  1931.     if ( abs ( h ) > maxhsofar ) 
  1932.     {
  1933.       if ( abs ( h ) > maxh + 99 ) 
  1934.       {
  1935.         if ( ! showing ) 
  1936.         {
  1937.           flushtext () ; 
  1938.           showing = true ; 
  1939.           tfatal ("%ld%s%s%ld%c",  (long)a , ": " , "warning: |h|>" , (long)maxh , '!' ) ; 
  1940.         } 
  1941.         else
  1942.         tfatal ("%c%s%ld%c",  ' ' , "warning: |h|>" , (long)maxh , '!' ) ; 
  1943.         maxh = abs ( h ) ; 
  1944.       } 
  1945.       maxhsofar = abs ( h ) ; 
  1946.     } 
  1947.     goto lab30 ; 
  1948.     lab45: if ( showing ) 
  1949.     {
  1950.     } 
  1951.     goto lab30 ; 
  1952.     lab30: ;
  1953.   } 
  1954.   lab9998: tfatal ("%c\n",  '!' ) ; 
  1955.   Result = false ; 
  1956.   lab9999: ; 
  1957.   return(Result) ; 
  1958. } 
  1959. skippages () {
  1960.     /* 9999 */ integer p  ; 
  1961.   unsigned char k  ; 
  1962.   integer downthedrain  ; 
  1963.   showing = false ; 
  1964.   while ( true ) {
  1965.       
  1966.     if ( eof ( dvifile ) ) 
  1967.     {
  1968.       tfatal ("%c%s%s%c",  ' ' , "Bad DVI file: " , "the file ended prematurely"       , '!' ) ; 
  1969.       uexit ( 1 ) ; 
  1970.     } 
  1971.     k = getbyte () ; 
  1972.     p = firstpar ( k ) ; 
  1973.     switch ( k ) 
  1974.     {case 139 : 
  1975.       {
  1976.         newbackpointer = curloc - 1 ; 
  1977.         pagecount = pagecount + 1 ; 
  1978.         {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end) 
  1979.         do 
  1980.           count [ k ] = signedquad () ; 
  1981.         while ( k++ < for_end ) ; } 
  1982.         if ( signedquad () != oldbackpointer ) 
  1983.         tfatal ("%s%ld%s%ld%c\n",  "backpointer in byte " , (long)curloc - 4 ,         " should be " , (long)oldbackpointer , '!' ) ; 
  1984.         oldbackpointer = newbackpointer ; 
  1985.         if ( ! started && startmatch () ) 
  1986.         {
  1987.           started = true ; 
  1988.           goto lab9999 ; 
  1989.         } 
  1990.       } 
  1991.       break ; 
  1992.     case 132 : 
  1993.     case 137 : 
  1994.       downthedrain = signedquad () ; 
  1995.       break ; 
  1996.     case 243 : 
  1997.     case 244 : 
  1998.     case 245 : 
  1999.     case 246 : 
  2000.       {
  2001.         definefont ( p ) ; 
  2002.       } 
  2003.       break ; 
  2004.     case 239 : 
  2005.     case 240 : 
  2006.     case 241 : 
  2007.     case 242 : 
  2008.       while ( p > 0 ) {
  2009.           
  2010.         downthedrain = getbyte () ; 
  2011.         p = p - 1 ; 
  2012.       } 
  2013.       break ; 
  2014.     case 248 : 
  2015.       {
  2016.         inpostamble = true ; 
  2017.         goto lab9999 ; 
  2018.       } 
  2019.       break ; 
  2020.       default: 
  2021.       ; 
  2022.       break ; 
  2023.     } 
  2024.   } 
  2025.   lab9999: ; 
  2026. } 
  2027. readpostamble () {
  2028.     integer k  ; 
  2029.   integer p, q, m  ; 
  2030.   showing = false ; 
  2031.   postloc = curloc - 5 ; 
  2032.   if ( signedquad () != numerator ) 
  2033.   tfatal ("%s\n",  "numerator doesn't match the preamble!" ) ; 
  2034.   if ( signedquad () != denominator ) 
  2035.   tfatal ("%s\n",  "denominator doesn't match the preamble!" ) ; 
  2036.   if ( signedquad () != mag ) 
  2037.   if ( newmag == 0 ) 
  2038.   tfatal ("%s\n",  "magnification doesn't match the preamble!" ) ; 
  2039.   maxv = signedquad () ; 
  2040.   maxh = signedquad () ; 
  2041.   maxs = gettwobytes () ; 
  2042.   totalpages = gettwobytes () ; 
  2043.   if ( outmode < 3 ) 
  2044.   {
  2045.     if ( maxv + 99 < maxvsofar ) 
  2046.     tfatal ("%s%ld\n",  "warning: observed maxv was " , (long)maxvsofar ) ; 
  2047.     if ( maxh + 99 < maxhsofar ) 
  2048.     if (debug) fprintf( stderr , "%s%ld\n",  "warning: observed maxh was " , (long)maxhsofar ) ; 
  2049.     if ( maxs < maxssofar ) 
  2050.     tfatal ("%s%ld\n",  "warning: observed maxstackdepth was " , (long)maxssofar ) 
  2051.     ; 
  2052.     if ( pagecount != totalpages ) 
  2053.     tfatal ("%s%ld%s%ld%c\n",  "there are really " , (long)pagecount , " pages, not " ,     (long)totalpages , '!' ) ; 
  2054.   } 
  2055.   do {
  2056.       k = getbyte () ; 
  2057.     if ( ( k >= 243 ) && ( k < 247 ) ) 
  2058.     {
  2059.       p = firstpar ( k ) ; 
  2060.       definefont ( p ) ; 
  2061.       k = 138 ; 
  2062.     } 
  2063.   } while ( ! ( k != 138 ) ) ; 
  2064.   if ( k != 249 ) 
  2065.   tfatal ("%s%ld%s\n",  "byte " , (long)curloc - 1 , " is not postpost!" ) ; 
  2066.   q = signedquad () ; 
  2067.   if ( q != postloc ) 
  2068.   tfatal ("%s%ld%c\n",  "bad postamble pointer in byte " , (long)curloc - 4 , '!' ) ; 
  2069.   m = getbyte () ; 
  2070.   if ( m != 2 ) 
  2071.   tfatal ("%s%ld%s%ld%c\n",  "identification in byte " , (long)curloc - 1 , " should be "   , (long)2 , '!' ) ; 
  2072.   k = curloc ; 
  2073.   m = 223 ; 
  2074.   while ( ( m == 223 ) && ! eof ( dvifile ) ) m = getbyte () ; 
  2075.   if ( ! eof ( dvifile ) ) 
  2076.   {
  2077.     tfatal ("%c%s%s%ld%s%c",  ' ' , "Bad DVI file: " , "signature in byte " , (long)curloc     - 1 , " should be 223" , '!' ) ; 
  2078.     uexit ( 1 ) ; 
  2079.   } 
  2080.   else if ( curloc < k + 4 ) 
  2081.   tfatal ("%s%ld%c\n",  "not enough signature bytes at end of file (" , (long)curloc   - k , ')' ) ; 
  2082.  
  2083.   /* *Should* be safe now to close the dvifile */
  2084.   fclose(dvifile);
  2085.  
  2086. } 
  2087. main_body() {
  2088.     
  2089.   initialize () ; 
  2090.   dialog () ; 
  2091.   opendvifile () ; 
  2092.   p = getbyte () ; 
  2093.   if ( p != 247 ) 
  2094.   {
  2095.     tfatal ("%c%s%s%c",  ' ' , "Bad DVI file: " ,     "First byte isn't start of preamble!" , '!' ) ; 
  2096.     uexit ( 1 ) ; 
  2097.   } 
  2098.   p = getbyte () ; 
  2099.   if ( p != 2 ) 
  2100.   tfatal ("%s%ld%c\n",  "identification in byte 1 should be " , (long)2 , '!' ) ; 
  2101.   numerator = signedquad () ; 
  2102.   denominator = signedquad () ; 
  2103.   if ( numerator <= 0 ) 
  2104.   {
  2105.     tfatal ("%c%s%s%ld%c",  ' ' , "Bad DVI file: " , "numerator is " , (long)numerator ,     '!' ) ; 
  2106.     uexit ( 1 ) ; 
  2107.   } 
  2108.   if ( denominator <= 0 ) 
  2109.   {
  2110.     tfatal ("%c%s%s%ld%c",  ' ' , "Bad DVI file: " , "denominator is " ,     (long)denominator , '!' ) ; 
  2111.     uexit ( 1 ) ; 
  2112.   } 
  2113.   conv = ( numerator / ((double) 254000.0 ) ) * ( resolution / ((double) 
  2114.   denominator ) ) ; 
  2115.   mag = signedquad () ; 
  2116.   if ( newmag > 0 ) 
  2117.   mag = newmag ; 
  2118.   else if ( mag <= 0 ) 
  2119.   {
  2120.     tfatal ("%c%s%s%ld%c",  ' ' , "Bad DVI file: " , "magnification is " , (long)mag ,     '!' ) ; 
  2121.     uexit ( 1 ) ; 
  2122.   } 
  2123.   trueconv = conv ; 
  2124.   conv = trueconv * ( mag / ((double) 1000.0 ) ) ; 
  2125.   p = getbyte () ; 
  2126. #ifndef ARM
  2127.   if ( outmode == 3 ) 
  2128.   {
  2129.     n = dvilength () ;
  2130.     if ( n < 53 ) 
  2131.     {
  2132.       (void) fprintf( stderr ,
  2133.          "%c%s%s%ld%s%c",  ' ' ,
  2134.           "Bad DVI file: " , "only " , (long)n , " bytes long"       , '!' ) ; 
  2135.       uexit ( 1 ) ; 
  2136.     } 
  2137.     m = n - 4 ; 
  2138.     do {
  2139.         if ( m == 0 ) 
  2140.       {
  2141.         (void) fprintf( stderr ,
  2142.            "%c%s%s%c",  ' ' , "Bad DVI file: " , "all 223s" , '!' ) ; 
  2143.         uexit ( 1 ) ; 
  2144.       } 
  2145.       movetobyte ( m ) ; 
  2146.       k = getbyte () ; 
  2147.       m = m - 1 ; 
  2148.     } while ( ! ( k != 223 ) ) ; 
  2149.     if ( k != 2 ) 
  2150.     {
  2151.       tfatal ("%c%s%s%ld%c",  ' ' , "Bad DVI file: " , "ID byte is " , (long)k , '!' ) ; 
  2152.       uexit ( 1 ) ; 
  2153.     } 
  2154.     movetobyte ( m - 3 ) ; 
  2155.     q = signedquad () ; 
  2156.     if ( ( q < 0 ) || ( q > m - 33 ) ) 
  2157.     {
  2158.       tfatal ("%c%s%s%ld%s%ld%c",  ' ' , "Bad DVI file: " , "post pointer " , (long)q ,       " at byte " , (long)m - 3 , '!' ) ; 
  2159.       uexit ( 1 ) ; 
  2160.     } 
  2161.     movetobyte ( q ) ; 
  2162.     k = getbyte () ; 
  2163.     if ( k != 248 ) 
  2164.     {
  2165.       tfatal ("%c%s%s%ld%s%c",  ' ' , "Bad DVI file: " , "byte " , (long)q , " is not post"       , '!' ) ; 
  2166.       uexit ( 1 ) ; 
  2167.     } 
  2168.     postloc = q ; 
  2169.     firstbackpointer = signedquad () ; 
  2170.     inpostamble = true ; 
  2171.     readpostamble () ; 
  2172.  
  2173.  
  2174.     inpostamble = false ; 
  2175.     q = postloc ; 
  2176.     p = firstbackpointer ; 
  2177.     startloc = -1 ; 
  2178.     if ( p < 0 ) 
  2179.     inpostamble = true ; 
  2180.     else {
  2181.         
  2182.       do {
  2183.           if ( p > q - 46 ) 
  2184.         {
  2185.           tfatal ("%c%s%s%ld%s%ld%c",  ' ' , "Bad DVI file: " , "page link " , (long)p ,           " after byte " , (long)q , '!' ) ; 
  2186.           uexit ( 1 ) ; 
  2187.         } 
  2188.         q = p ; 
  2189.         movetobyte ( q ) ; 
  2190.         k = getbyte () ; 
  2191.         if ( k == 139 ) 
  2192.         pagecount = pagecount + 1 ; 
  2193.         else {
  2194.             
  2195.           tfatal ("%c%s%s%ld%s%c",  ' ' , "Bad DVI file: " , "byte " , (long)q ,           " is not bop" , '!' ) ; 
  2196.           uexit ( 1 ) ; 
  2197.         } 
  2198.         {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end) 
  2199.         do 
  2200.           count [ k ] = signedquad () ; 
  2201.         while ( k++ < for_end ) ; } 
  2202.         if ( startmatch () ) 
  2203.         startloc = q ; 
  2204.         p = signedquad () ; 
  2205.       } while ( ! ( p < 0 ) ) ; 
  2206.       if ( startloc < 0 ) 
  2207.       {
  2208.         tfatal ("%c%s",  ' ' , "starting page number could not be found!" ) 
  2209.         ; 
  2210.         uexit ( 1 ) ; 
  2211.       } 
  2212.       movetobyte ( startloc + 1 ) ; 
  2213.       oldbackpointer = startloc ; 
  2214.       {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end) do 
  2215.         count [ k ] = signedquad () ; 
  2216.       while ( k++ < for_end ) ; } 
  2217.       p = signedquad () ; 
  2218.       started = true ; 
  2219.     } 
  2220.     if ( pagecount != totalpages ) 
  2221.     tfatal ("%s%ld%s%ld%c\n",  "there are really " , (long)pagecount , " pages, not " ,     (long)totalpages , '!' ) ; 
  2222.   } 
  2223.   else
  2224. #endif
  2225.     skippages () ; 
  2226.   if ( ! inpostamble ) 
  2227.   {
  2228.     while ( maxpages > 0 ) {
  2229.         
  2230.       maxpages = maxpages - 1 ; 
  2231.       {register integer for_end; k = 0 ; for_end = startvals ;
  2232.       while ( k++ < for_end ) ; } 
  2233.       if ( ! dopage () ) 
  2234.       {
  2235.         tfatal ("%c%s%s%c",  ' ' , "Bad DVI file: " , "page ended unexpectedly"         , '!' ) ; 
  2236.         uexit ( 1 ) ; 
  2237.       } 
  2238.       do {
  2239.           k = getbyte () ; 
  2240.         if ( ( k >= 243 ) && ( k < 247 ) ) 
  2241.         {
  2242.           p = firstpar ( k ) ; 
  2243.           definefont ( p ) ; 
  2244.           k = 138 ; 
  2245.         } 
  2246.       } while ( ! ( k != 138 ) ) ; 
  2247.       if ( k == 248 ) 
  2248.       {
  2249.         inpostamble = true ; 
  2250.         goto lab30 ; 
  2251.       } 
  2252.       if ( k != 139 ) 
  2253.       {
  2254.         tfatal ("%c%s%s%ld%s%c",  ' ' , "Bad DVI file: " , "byte " , (long)curloc - 1 ,         " is not bop" , '!' ) ; 
  2255.         uexit ( 1 ) ; 
  2256.       } 
  2257.       newbackpointer = curloc - 1 ; 
  2258.       pagecount = pagecount + 1 ; 
  2259.       {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end) do 
  2260.         count [ k ] = signedquad () ; 
  2261.       while ( k++ < for_end ) ; } 
  2262.       if ( signedquad () != oldbackpointer ) 
  2263.       tfatal ("%s%ld%s%ld%c\n",  "backpointer in byte " , (long)curloc - 4 , " should be "       , (long)oldbackpointer , '!' ) ; 
  2264.       oldbackpointer = newbackpointer ; 
  2265.     } 
  2266.     lab30: ; 
  2267.   } 
  2268.   if ( outmode < 3 ) 
  2269.   {
  2270.     if ( ! inpostamble ) 
  2271.     skippages () ; 
  2272.     if ( signedquad () != oldbackpointer ) 
  2273.     tfatal ("%s%ld%s%ld%c\n",  "backpointer in byte " , (long)curloc - 4 , " should be " ,     (long)oldbackpointer , '!' ) ; 
  2274.     readpostamble () ; 
  2275.   } 
  2276. }
  2277.